[Chapter Twenty-Four] [Previous]
[Next] [Art of
Assembly][Randall Hyde]
Art of Assembly: Chapter Twenty-Four
- 24.5.13 - An SGDI Driver for the Standard
Game Adapter Card
24.5.13 An SGDI Driver for the Standard Game Adapter Card
If you write your program to make SGDI calls, you will discover that
the TestPresence call will probably return "not present"
when your program searches for a resident SGDI driver in memory. This is
because few manufacturers provide SGDI drivers at this point and even fewer
standard game adapter companies ship any software at all with their products,
much less an SGDI driver. Gee, what kind of standard is this if no one uses
it? Well, the purpose of this section is to rectify that problem.
The assembly code that appears at the end of this section provides a fully
functional, public domain, SGDI driver for the standard game adapter card
(the next section present an SGDI driver for the CH Products' Flightstick
Pro). This allows you to write your application making only SGDI calls.
By supplying the SGDI TSR with your product, your customers can use your
software with all standard joysticks. Later, if they purchase a specialized
device with its own SGDI driver, your software will automatically work with
that driver with no changes to your software.
If you do not like the idea of having a user run a TSR before your application,
you can always include the following code within your program's code space
and activate it if the SGDI TestPresence call determines that
no other SGDI driver is present in memory when you start your program.
Here's the complete code for the standard game adapter SGDI driver:
.286
page 58, 132
name SGDI
title SGDI Driver for Standard Game Adapter Card
subttl This Program is Public Domain Material.
; SGDI.EXE
;
; Usage:
; SDGI
;
; This program loads a TSR which patches INT 15 so arbitrary game programs
; can read the joystick in a portable fashion.
;
;
; We need to load cseg in memory before any other segments!
cseg segment para public 'code'
cseg ends
; Initialization code, which we do not need except upon initial load,
; goes in the following segment:
Initialize segment para public 'INIT'
Initialize ends
; UCR Standard Library routines which get dumped later on.
.xlist
include stdlib.a
includelib stdlib.lib
.list
sseg segment para stack 'stack'
sseg ends
zzzzzzseg segment para public 'zzzzzzseg'
zzzzzzseg ends
CSEG segment para public 'CODE'
assume cs:cseg, ds:nothing
wp equ <word ptr>
byp equ <byte ptr>
Int15Vect dword 0
PSP word ?
; Port addresses for a typical joystick card:
JoyPort equ 201h
JoyTrigger equ 201h
; Data structure to hold information about each pot.
; (mainly for calibration and normalization purposes).
Pot struc
PotMask byte 0 ;Pot mask for hardware.
DidCal byte 0 ;Is this pot calibrated?
min word 5000 ;Minimum pot value
max word 0 ;Max pot value
center word 0 ;Pot value in the middle
Pot ends
; Variables for each of the pots. Must initialize the masks so they
; mask out all the bits except the incomming bit for each pot.
Pot0 Pot <1>
Pot1 Pot <2>
Pot2 Pot <4>
Pot3 Pot <8>
; The IDstring address gets passed back to the caller on a testpresence
; call. The four bytes before the IDstring must contain the serial number
; and current driver number.
SerialNumber byte 0,0,0
IDNumber byte 0
IDString byte "Standard SGDI Driver",0
byte "Public Domain Driver Written by Randall L. Hyde",0
;============================================================================
;
; ReadPots- AH contains a bit mask to determine which pots we should read.
; Bit 0 is one if we should read pot 0, bit 1 is one if we should
; read pot 1, bit 2 is one if we should read pot 2, bit 3 is one
; if we should read pot 3. All other bits will be zero.
;
; This code returns the pot values in SI, BX, BP, and DI for Pot 0, 1,
; 2, & 3.
;
ReadPots proc near
sub bp, bp
mov si, bp
mov di, bp
mov bx, bp
; Wait for any previous signals to finish up before trying to read this
; guy. It is possible that the last pot we read was very short. However,
; the trigger signal starts timers running for all four pots. This code
; terminates as soon as the current pot times out. If the user immediately
; reads another pot, it is quite possible that the new pot's timer has
; not yet expired from the previous read. The following loop makes sure we
; aren't measuring the time from the previous read.
mov dx, JoyPort
mov cx, 400h
Wait4Clean: in al, dx
and al, 0Fh
loopnz Wait4Clean
; Okay, read the pots. The following code triggers the 558 timer chip
; and then sits in a loop until all four pot bits (masked with the pot mask
; in AL) become zero. Each time through this loop that one or more of these
; bits contain zero, this loop increments the corresponding register(s).
mov dx, JoyTrigger
out dx, al ;Trigger pots
mov dx, JoyPort
mov cx, 1000h ;Don't let this go on forever.
PotReadLoop: in al, dx
and al, ah
jz PotReadDone
shr al, 1
adc si, 0 ;Increment SI if pot 0 still active.
shr al, 1
adc bx, 0 ;Increment BX if pot 1 still active.
shr al, 1
adc bp, 0 ;Increment BP if pot 2 still active.
shr al, 1
adc di, 0 ;Increment DI if pot 3 still active.
loop PotReadLoop ;Stop, eventually, if funny hardware.
and si, 0FFFh ;If we drop through to this point,
and bx, 0FFFh ; one or more pots timed out (usually
and bp, 0FFFh ; because they are not connected).
and di, 0FFFh ; The reg contains 4000h, set it to 0.
PotReadDone: ret
ReadPots endp
;----------------------------------------------------------------------------
;
; Normalize- BX contains a pointer to a pot structure, AX contains
; a pot value. Normalize that value according to the
; calibrated pot.
;
; Note: DS must point at cseg before calling this routine.
assume ds:cseg
Normalize proc near
push cx
; Sanity check to make sure the calibration process went okay.
cmp [bx].Pot.DidCal, 0 ;Is this pot calibrated?
je BadNorm ;If not, quit.
mov dx, [bx].Pot.Center ;Do a sanity check on the
cmp dx, [bx].Pot.Min ; min, center, and max
jbe BadNorm ; values to make sure
cmp dx, [bx].Pot.Max ; min < center < max.
jae BadNorm
; Clip the value if it is out of range.
cmp ax, [bx].Pot.Min ;If the value is less than
ja MinOkay ; the minimum value, set it
mov ax, [bx].Pot.Min ; to the minimum value.
MinOkay:
cmp ax, [bx].Pot.Max ;If the value is greater than
jb MaxOkay ; the maximum value, set it
mov ax, [bx].Pot.Max ; to the maximum value.
MaxOkay:
; Scale this guy around the center:
cmp ax, [bx].Pot.Center ;See if less than or greater
jb Lower128 ; than centered value.
; Okay, current reading is greater than the centered value, scale the reading
; into the range 128..255 here:
sub ax, [bx].Pot.Center
mov dl, ah ;Multiply by 128
mov ah, al
mov dh, 0
mov al, dh
shr dl, 1
rcr ax, 1
mov cx, [bx].Pot.Max
sub cx, [bx].Pot.Center
jz BadNorm ;Prevent division by zero.
div cx ;Compute normalized value.
add ax, 128 ;Scale to range 128..255.
cmp ah, 0
je NormDone
mov ax, 0ffh ;Result must fit in 8 bits!
jmp NormDone
; If the reading is below the centered value, scale it into the range
; 0..127 here:
Lower128: sub ax, [bx].Pot.Min
mov dl, ah
mov ah, al
mov dh, 0
mov al, dh
shr dl, 1
rcr ax, 1
mov cx, [bx].Pot.Center
sub cx, [bx].Pot.Min
jz BadNorm
div cx
cmp ah, 0
je NormDone
mov ax, 0ffh
jmp NormDone
; If something went wrong, return zero as the normalized value.
BadNorm: sub ax, ax
NormDone: pop cx
ret
Normalize endp
assume ds:nothing
;============================================================================
; INT 15h handler functions.
;============================================================================
;
; Although these are defined as near procs, they are not really procedures.
; The MyInt15 code jumps to each of these with BX, a far return address, and
; the flags sitting on the stack. Each of these routines must handle the
; stack appropriately.
;
;----------------------------------------------------------------------------
; BIOS- Handles the two BIOS calls, DL=0 to read the switches, DL=1 to
; read the pots. For the BIOS routines, we'll ignore the cooley
; switch (the hat) and simply read the other four switches.
BIOS proc near
cmp dl, 1 ;See if switch or pot routine.
jb Read4Sw
je ReadBIOSPots
; If not a valid BIOS call, jump to the original INT 15 handler and
; let it take care of this call.
pop bx
jmp cs:Int15Vect ;Let someone else handle it!
; BIOS read switches function.
Read4Sw: push dx
mov dx, JoyPort
in al, dx
and al, 0F0h ;Return only switch values.
pop dx
pop bx
iret
; BIOS read pots function.
ReadBIOSPots: pop bx ;Return a value in BX!
push si
push di
push bp
mov ah, 0Fh ;Read all four pots.
call ReadPots
mov ax, si
mov cx, bp ;BX already contains pot 1 reading.
mov dx, di
pop bp
pop di
pop si
iret
BIOS endp
;----------------------------------------------------------------------------
;
; ReadPot- On entry, DL contains a pot number to read.
; Read and normalize that pot and return the result in AL.
assume ds:cseg
ReadPot proc near
;;;;;;;;;; push bx ;Already on stack.
push ds
push cx
push dx
push si
push di
push bp
mov bx, cseg
mov ds, bx
; If dl = 0, read and normalize the value for pot 0, if not, try some
; other pot.
cmp dl, 0
jne Try1
mov ah, Pot0.PotMask ;Get bit for this pot.
call ReadPots ;Read pot 0.
lea bx, Pot0 ;Pointer to pot data.
mov ax, si ;Get pot 0 reading.
call Normalize ;Normalize to 0..FFh.
jmp GotPot ;Return to caller.
; Test for DL=1 here (read and normalize pot 1).
Try1: cmp dl, 1
jne Try2
mov ah, Pot1.PotMask
call ReadPots
mov ax, bx
lea bx, Pot1
call Normalize
jmp GotPot
; Test for DL=2 here (read and normalize pot 2).
Try2: cmp dl, 2
jne Try3
mov ah, Pot2.PotMask
call ReadPots
lea bx, Pot2
mov ax, bp
call Normalize
jmp GotPot
; Test for DL=3 here (read and normalize pot 3).
Try3: cmp dl, 3
jne BadPot
mov ah, Pot3.PotMask
call ReadPots
lea bx, Pot3
mov ax, di
call Normalize
jmp GotPot
; Bad value in DL if we drop to this point. The standard game card
; only supports four pots.
BadPot: sub ax, ax ;Pot not available, return zero.
GotPot: pop bp
pop di
pop si
pop dx
pop cx
pop ds
pop bx
iret
ReadPot endp
assume ds:nothing
;----------------------------------------------------------------------------
;
; ReadRaw- On entry, DL contains a pot number to read.
; Read that pot and return the unnormalized result in AX.
assume ds:cseg
ReadRaw proc near
;;;;;;;;;; push bx ;Already on stack.
push ds
push cx
push dx
push si
push di
push bp
mov bx, cseg
mov ds, bx
; This code is almost identical to the ReadPot code. The only difference
; is that we don't bother normalizing the result and (of course) we return
; the value in AX rather than AL.
cmp dl, 0
jne Try1
mov ah, Pot0.PotMask
call ReadPots
mov ax, si
jmp GotPot
Try1: cmp dl, 1
jne Try2
mov ah, Pot1.PotMask
call ReadPots
mov ax, bx
jmp GotPot
Try2: cmp dl, 2
jne Try3
mov ah, Pot2.PotMask
call ReadPots
mov ax, bp
jmp GotPot
Try3: cmp dl, 3
jne BadPot
mov ah, Pot3.PotMask
call ReadPots
mov ax, di
jmp GotPot
BadPot: sub ax, ax ;Pot not available, return zero.
GotPot: pop bp
pop di
pop si
pop dx
pop cx
pop ds
pop bx
iret
ReadRaw endp
assume ds:nothing
;----------------------------------------------------------------------------
; Read4Pots- Reads pots zero, one, two, and three returning their
; values in AL, AH, DL, and DH.
;
; On entry, AL contains the pot mask to select which pots
; we should read (bit 0=1 for pot 0, bit 1=1 for pot 1, etc).
Read4Pots proc near
;;;;;;;;;;; push bx ;Already on stack
push ds
push cx
push si
push di
push bp
mov dx, cseg
mov ds, dx
mov ah, al
call ReadPots
push bx ;Save pot 1 reading.
mov ax, si ;Get pot 0 reading.
lea bx, Pot0 ;Point bx at pot0 vars.
call Normalize ;Normalize.
mov cl, al ;Save for later.
pop ax ;Retreive pot 1 reading.
lea bx, Pot1
call Normalize
mov ch, al ;Save normalized value.
mov ax, bp
lea bx, Pot2
call Normalize
mov dl, al ;Pot 2 value.
mov ax, di
lea bx, Pot3
call Normalize
mov dh, al ;Pot 3 value.
mov ax, cx ;Pots 0 and 1.
pop bp
pop di
pop si
pop cx
pop ds
pop bx
iret
Read4Pots endp
;----------------------------------------------------------------------------
; CalPot- Calibrate the pot specified by DL. On entry, AL contains
; the minimum pot value (it better be less than 256!), BX
; contains the maximum pot value, and CX contains the centered
; pot value.
assume ds:cseg
CalPot proc near
pop bx ;Retrieve maximum value
push ds
push si
mov si, cseg
mov ds, si
; Sanity check on parameters, sort them in ascending order:
mov ah, 0
cmp bx, cx ;Make sure center < max
ja GoodMax
xchg bx, cx
GoodMax: cmp ax, cx ;Make sure min < center.
jb GoodMin ; (note: may make center<max).
xchg ax, cx
GoodMin: cmp cx, bx ;Again, be sure center < max.
jb GoodCenter
xchg cx, bx
GoodCenter:
; Okay, figure out who were supposed to calibrate:
lea si, Pot0
cmp dl, 1
jb DoCal ;Branch if this is pot 0
lea si, Pot1
je DoCal ;Branch if this is pot 1
lea si, Pot2
cmp dl, 3
jb DoCal ;Branch if this is pot 2
jne CalDone ;Branch if not pot 3
lea si, Pot3
DoCal: mov [si].Pot.min, ax ;Store away the minimum,
mov [si].Pot.max, bx ; maximum, and
mov [si].Pot.center, cx ; centered values.
mov [si].Pot.DidCal, 1 ;Note we've cal'd this pot.
CalDone: pop si
pop ds
iret
CalPot endp
assume ds:nothing
;----------------------------------------------------------------------------
; TestCal- Just checks to see if the pot specified by DL has already
; been calibrated.
assume ds:cseg
TestCal proc near
;;;;;;;; push bx ;Already on stack
push ds
mov bx, cseg
mov ds, bx
sub ax, ax ;Assume no calibration (also zeros AH)
lea bx, Pot0 ;Get the address of the specified
cmp dl, 1 ; pot's data structure into the
jb GetCal ; BX register.
lea bx, Pot1
je GetCal
lea bx, Pot2
cmp dl, 3
jb GetCal
jne BadCal
lea bx, Pot3
GetCal: mov al, [bx].Pot.DidCal
BadCal: pop ds
pop bx
iret
TestCal endp
assume ds:nothing
;----------------------------------------------------------------------------
;
; ReadSw- Reads the switch whose switch number appears in DL.
ReadSw proc near
;;;;;;; push bx ;Already on stack
push cx
sub ax, ax ;Assume no such switch.
cmp dl, 3 ;Return if the switch number is
ja NotDown ; greater than three.
mov cl, dl ;Save switch to read.
add cl, 4 ;Move from position four down to zero.
mov dx, JoyPort
in al, dx ;Read the switches.
shr al, cl ;Move desired switch bit into bit 0.
xor al, 1 ;Invert so sw down=1.
and ax, 1 ;Remove other junk bits.
NotDown: pop cx
pop bx
iret
ReadSw endp
;----------------------------------------------------------------------------
;
; Read16Sw- Reads all four switches and returns their values in AX.
Read16Sw proc near
;;;;;;;; push bx ;Already on stack
mov dx, JoyPort
in al, dx
shr al, 4
xor al, 0Fh ;Invert all switches.
and ax, 0Fh ;Set other bits to zero.
pop bx
iret
Read16Sw endp
;****************************************************************************
;
; MyInt15- Patch for the BIOS INT 15 routine to control reading the
; joystick.
MyInt15 proc far
push bx
cmp ah, 84h ;Joystick code?
je DoJoystick
OtherInt15: pop bx
jmp cs:Int15Vect
DoJoystick: mov bh, 0
mov bl, dh
cmp bl, 80h
jae VendorCalls
cmp bx, JmpSize
jae OtherInt15
shl bx, 1
jmp wp cs:jmptable[bx]
jmptable word BIOS
word ReadPot, Read4Pots, CalPot, TestCal
word ReadRaw, OtherInt15, OtherInt15
word ReadSw, Read16Sw
JmpSize = ($-jmptable)/2
; Handle vendor specific calls here.
VendorCalls: je RemoveDriver
cmp bl, 81h
je TestPresence
pop bx
jmp cs:Int15Vect
; TestPresence- Returns zero in AX and a pointer to the ID string in ES:BX
TestPresence: pop bx ;Get old value off stack.
sub ax, ax
mov bx, cseg
mov es, bx
lea bx, IDString
iret
; RemoveDriver- If there are no other drivers loaded after this one in
; memory, disconnect it and remove it from memory.
RemoveDriver:
push ds
push es
push ax
push dx
mov dx, cseg
mov ds, dx
; See if we're the last routine patched into INT 15h
mov ax, 3515h
int 21h
cmp bx, offset MyInt15
jne CantRemove
mov bx, es
cmp bx, wp seg MyInt15
jne CantRemove
mov ax, PSP ;Free the memory we're in
mov es, ax
push es
mov ax, es:[2ch] ;First, free env block.
mov es, ax
mov ah, 49h
int 21h
pop es ;Now free program space.
mov ah, 49h
int 21h
lds dx, Int15Vect ;Restore previous int vect.
mov ax, 2515h
int 21h
CantRemove: pop dx
pop ax
pop es
pop ds
pop bx
iret
MyInt15 endp
cseg ends
Initialize segment para public 'INIT'
assume cs:Initialize, ds:cseg
Main proc
mov ax, cseg ;Get ptr to vars segment
mov es, ax
mov es:PSP, ds ;Save PSP value away
mov ds, ax
mov ax, zzzzzzseg
mov es, ax
mov cx, 100h
meminit2
print
byte " Standard Game Device Interface driver",cr,lf
byte " PC Compatible Game Adapter Cards",cr,lf
byte " Written by Randall Hyde",cr,lf
byte cr,lf
byte cr,lf
byte "'SGDI REMOVE' removes the driver from memory",cr,lf
byte lf
byte 0
mov ax, 1
argv ;If no parameters, empty str.
stricmpl
byte "REMOVE",0
jne NoRmv
mov dh, 81h ;Remove opcode.
mov ax, 84ffh
int 15h ;See if we're already loaded.
test ax, ax ;Get a zero back?
jz Installed
print
byte "SGDI driver is not present in memory, REMOVE "
byte "command ignored.",cr,lf,0
mov ax, 4c01h ;Exit to DOS.
int 21h
Installed: mov ax, 8400h
mov dh, 80h ;Remove call
int 15h
mov ax, 8400h
mov dh, 81h ;TestPresence call
int 15h
cmp ax, 0
je NotRemoved
print
byte "Successfully removed SGDI driver from memory."
byte cr,lf,0
mov ax, 4c01h ;Exit to DOS.
int 21h
NotRemoved: print
byte "SGDI driver is still present in memory.",cr,lf,0
mov ax, 4c01h ;Exit to DOS.
int 21h
; Okay, Patch INT 15 and go TSR at this point.
NoRmv:
mov ax, 3515h
int 21h
mov wp Int15Vect, bx
mov wp Int15Vect+2, es
mov dx, cseg
mov ds, dx
mov dx, offset MyInt15
mov ax, 2515h
int 21h
mov dx, cseg
mov ds, dx
mov dx, seg Initialize
sub dx, ds:psp
add dx, 2
mov ax, 3100h ;Do TSR
int 21h
Main endp
Initialize ends
sseg segment para stack 'stack'
word 128 dup (0)
endstk word ?
sseg ends
zzzzzzseg segment para public 'zzzzzzseg'
byte 16 dup (0)
zzzzzzseg ends
end Main
The following program makes several different types of calls to an SGDI
driver. You can use this code to test out an SGDI TSR:
.xlist
include stdlib.a
includelib stdlib.lib
.list
cseg segment para public 'code'
assume cs:cseg, ds:nothing
MinVal0 word ?
MinVal1 word ?
MaxVal0 word ?
MaxVal1 word ?
; Wait4Button- Waits until the user presses and releases a button.
Wait4Button proc near
push ax
push dx
push cx
W4BLp: mov ah, 84h
mov dx, 900h ;Read the L.O. 16 buttons.
int 15h
cmp ax, 0 ;Any button down? If not,
je W4BLp ; loop until this is so.
xor cx, cx ;Debouncing delay loop.
Delay: loop Delay
W4nBLp: mov ah, 84h ;Now wait until the user releases
mov dx, 900h ; all buttons
int 15h
cmp ax, 0
jne W4nBLp
Delay2: loop Delay2
pop cx
pop dx
pop ax
ret
Wait4Button endp
Main proc
print
byte "SGDI Test Program.",cr,lf
byte "Written by Randall Hyde",cr,lf,lf
byte "Press any key to continue",cr,lf,0
getc
mov ah, 84h
mov dh, 4 ;Test presence call.
int 15h
cmp ax, 0 ;See if there
je MainLoop0
print
byte "No SGDI driver present in memory.",cr,lf,0
jmp Quit
MainLoop0: print
byte "BIOS: ",0
; Okay, read the switches and raw pot values using the BIOS compatible calls.
mov ah, 84h
mov dx, 0 ;BIOS compat. read switches.
int 15h
puth ;Output switch values.
mov al, ' '
putc
mov ah, 84h ;BIOS compat. read pots.
mov dx, 1
int 15h
putw
mov al, ' '
putc
mov ax, bx
putw
mov al, ' '
putc
mov ax, cx
putw
mov al, ' '
putc
mov ax, dx
putw
putcr
mov ah, 1 ;Repeat until key press.
int 16h
je MainLoop0
getc
; Read the minimum and maximum values for each pot from the user so we
; can calibrate the pots.
print
byte cr,lf,lf,lf
byte "Move joystick to upper left corner and press "
byte "any button.",cr,lf,0
call Wait4Button
mov ah, 84h
mov dx, 1 ;Read Raw Values
int 15h
mov MinVal0, ax
mov MinVal1, bx
print
byte cr,lf
byte "Move the joystick to the lower right corner "
byte "and press any button",cr,lf,0
call Wait4Button
mov ah, 84h
mov dx, 1 ;Read Raw Values
int 15h
mov MaxVal0, ax
mov MaxVal1, bx
; Calibrate the pots.
mov ax, MinVal0 ;Will be eight bits or less.
mov bx, MaxVal0
mov cx, bx ;Compute centered value as the
add cx, ax ; average of these two (this is
shr cx, 1 ; dangerous, but usually works!)
mov ah, 84h
mov dx, 300h ;Calibrate pot 0
int 15h
mov ax, MinVal1 ;Will be eight bits or less.
mov bx, MaxVal1
mov cx, bx ;Compute centered value as the
add cx, ax ; average of these two (this is
shr cx, 1 ; dangerous, but usually works!)
mov ah, 84h
mov dx, 301h ;Calibrate pot 1
int 15h
MainLoop1: print
byte "ReadSw: ",0
; Okay, read the switches and raw pot values using the BIOS compatible calls.
mov ah, 84h
mov dx, 800h ;Read switch zero.
int 15h
or al, '0'
putc
mov ah, 84h
mov dx, 801h ;Read switch one.
int 15h
or al, '0'
putc
mov ah, 84h
mov dx, 802h ;Read switch two.
int 15h
or al, '0'
putc
mov ah, 84h
mov dx, 803h ;Read switch three.
int 15h
or al, '0'
putc
mov ah, 84h
mov dx, 804h ;Read switch four
int 15h
or al, '0'
putc
mov ah, 84h
mov dx, 805h ;Read switch five.
int 15h
or al, '0'
putc
mov ah, 84h
mov dx, 806h ;Read switch six.
int 15h
or al, '0'
putc
mov ah, 84h
mov dx, 807h ;Read switch seven.
int 15h ;We won't bother with
or al, '0' ; any more switches.
putc
mov al, ' '
putc
mov ah, 84h
mov dh, 9 ;Read all 16 switches.
int 15h
putw
print
byte " Pots: ",0
mov ax, 8403h ;Read joystick pots.
mov dx, 200h ;Read four pots.
int 15h
puth
mov al, ' '
putc
mov al, ah
puth
mov al, ' '
putc
mov ah, 84h
mov dx, 503h ;Raw read, pot 3.
int 15h
putw
putcr
mov ah, 1 ;Repeat until key press.
int 16h
je MainLoop1
getc
Quit: ExitPgm ;DOS macro to quit program.
Main endp
cseg ends
sseg segment para stack 'stack'
stk byte 1024 dup ("stack ")
sseg ends
zzzzzzseg segment para public 'zzzzzz'
LastBytes byte 16 dup (?)
zzzzzzseg ends
end Main
- 24.5.13 - An SGDI Driver for
the Standard Game Adapter Card
Art of Assembly: Chapter Twenty-Four - 29 SEP 1996
[Chapter Twenty-Four][Previous] [Next]
[Art of Assembly][Randall
Hyde]